import axios from 'axios'
import { API_CONFIG, getApiUrl } from './config'
import { getToken } from '@/utils/auth'

// 使用统一的API配置
const API_BASE_URL = API_CONFIG.BASE_URL

/**
 * 使用 SSE 方式调用聊天接口 - 支持身份认证和对话历史
 * @param {string} message 用户消息
 * @param {Function} onMessage 接收消息的回调函数
 * @param {Function} onError 错误处理回调函数
 * @param {Function} onClose 连接关闭回调函数
 * @param {number|null} sessionId 会话ID (可选，如果提供则使用该会话)
 * @returns {EventSource} 返回 EventSource 对象，用于手动关闭连接
 */
export function chatWithSSE(message, onMessage, onError, onClose, sessionId = null) {
    // 获取认证Token
    const token = getToken()
    if (!token) {
        onError && onError(new Error('未登录，请先登录'))
        return null
    }
    
    // 构建URL参数
    const params = new URLSearchParams({
        message: message
    })
    
    // 如果提供了sessionId，则添加到参数中
    if (sessionId) {
        params.append('sessionId', sessionId)
    }
    
    // 创建 EventSource 连接（注意：EventSource 不支持自定义请求头，需要通过URL参数传递token）
    const url = `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.CHAT}?${params}&token=${encodeURIComponent(token)}`
    const eventSource = new EventSource(url)
    
    // 处理接收到的消息
    eventSource.onmessage = function(event) {
        try {
            // 检查是否是完成信号
            if (event.data === '[DONE]') {
                console.log('AI回复完成')
                eventSource.close()
                onClose && onClose()
                return
            }
            
            // 尝试解析JSON，如果失败则直接使用原始数据
            let content = event.data
            try {
                const data = JSON.parse(event.data)
                if (data && data.content) {
                    content = data.content
                }
            } catch (jsonError) {
                // 如果不是JSON格式，直接使用原始数据
                content = event.data
            }
            
            // 不丢弃空白字符，保持原始流式效果
            if (content !== undefined && content !== null) {
                onMessage && onMessage(content)
            }
        } catch (error) {
            console.error('处理消息失败:', error)
            onError && onError(error)
        }
    }
    
    // 处理错误
    eventSource.onerror = function(error) {
        console.log('SSE 连接状态:', eventSource.readyState)
        // 只有在连接状态不是正常关闭时才报错
        if (eventSource.readyState !== EventSource.CLOSED) {
            console.error('SSE 连接错误:', error)
            onError && onError(error)
        } else {
            console.log('SSE 连接正常结束')
        }
        
        // 确保连接关闭
        if (eventSource.readyState !== EventSource.CLOSED) {
            eventSource.close()
        }
    }
    
    // 处理连接关闭
    eventSource.onclose = function() {
        console.log('SSE 连接已关闭')
        onClose && onClose()
    }
    
    return eventSource
}

// 面试SSE
export function interviewWithSSE(paramsObj, onMessage, onError, onClose) {
    const token = getToken();
    if (!token) {
        onError('未登录');
        return null;
    }

    const params = new URLSearchParams();
    for (const key in paramsObj) {
        if (paramsObj.hasOwnProperty(key) && paramsObj[key] !== null && paramsObj[key] !== undefined) {
            if (Array.isArray(paramsObj[key])) {
                params.append(key, paramsObj[key].join('、')); // Join array with '、'
            } else {
                params.append(key, paramsObj[key]);
            }
        }
    }
    params.append('token', token);

    const url = `${API_BASE_URL}/ai/interview?${params.toString()}`;
    console.log('面试API调用URL:', url);

    const eventSource = new EventSource(url);
    
    eventSource.onmessage = function(event) {
        if (event.data === '[DONE]') {
            eventSource.close();
            onClose();
        } else {
            onMessage(event.data);
        }
    };

    eventSource.onerror = function(event) {
        console.error('EventSource error:', event);
        onError('连接错误');
        eventSource.close();
    };

    return eventSource;
}

// 历史与收尾接口已移除，面试历史复用会话接口；收尾由提示词生成总结，不在此处单独落库
export async function getInterviewHistory() {
    const token = getToken()
    const response = await axios.get(`${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.INTERVIEW_HISTORY}`, { params: { token } })
    return response.data
}

// 新建面试历史记录
export async function createInterview(payload = {}) {
    const token = getToken()
    const params = { token, ...payload }
    const response = await axios.post(`${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.INTERVIEW_CREATE}`, null, { params })
    return response.data
}

// 删除面试历史记录
export async function deleteInterview(id) {
    const token = getToken()
    const response = await axios.delete(`${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.INTERVIEW_DELETE}`, { params: { token, id } })
    return response.data
}

/**
 * 保存AI对话历史
 * @param {Array} aiTalkList 对话历史列表
 * @returns {Promise} 保存结果
 */
export async function saveAiTalks(aiTalkList) {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.post(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.SAVE_TALKS}`,
            aiTalkList,
            {
                headers: {
                    'Authorization': token,
                    'Content-Type': 'application/json'
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('保存对话历史失败:', error)
        throw error
    }
}

/**
 * 清除AI对话历史
 * @returns {Promise} 清除结果
 */
export async function clearAiTalks() {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.delete(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.CLEAR_TALKS}`,
            {
                headers: {
                    'Authorization': token
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('清除对话历史失败:', error)
        throw error
    }
}

/**
 * 获取AI聊天历史记录（兼容旧版本）
 * @returns {Promise} 历史记录数据
 */
export async function getChatHistory() {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.get(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.GET_HISTORY}`,
            {
                params: {
                    token: token
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('获取聊天历史失败:', error)
        throw error
    }
}

/**
 * 获取用户的聊天会话列表
 * @returns {Promise} 会话列表数据
 */
export async function getChatSessions() {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.get(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.GET_SESSIONS}`,
            {
                params: {
                    token: token
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('获取会话列表失败:', error)
        throw error
    }
}

/**
 * 获取会话的所有消息
 * @param {number} sessionId 会话ID
 * @returns {Promise} 消息列表数据
 */
export async function getSessionMessages(sessionId) {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.get(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.GET_SESSION_MESSAGES}`,
            {
                params: {
                    token: token,
                    sessionId: sessionId
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('获取会话消息失败:', error)
        throw error
    }
}

/**
 * 面试回合检查并在达上限时拉取评估JSON
 * @param {number} sessionId 面试会话ID
 */
export async function checkAndEvaluateInterview(sessionId) {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    const response = await axios.get(`${API_BASE_URL}/ai/interview/checkAndEvaluate`, {
        params: { token, sessionId }
    })
    return response.data
}

/**
 * 创建新的聊天会话
 * @param {string} initialMessage 初始消息
 * @returns {Promise} 会话信息
 */
export async function createChatSession(initialMessage) {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.post(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.CREATE_SESSION}`,
            null,
            {
                params: {
                    token: token,
                    initialMessage: initialMessage
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('创建会话失败:', error)
        throw error
    }
}

/**
 * 删除聊天会话
 * @param {number} sessionId 会话ID
 * @returns {Promise} 操作结果
 */
export async function deleteChatSession(sessionId) {
    const token = getToken()
    if (!token) {
        throw new Error('未登录，请先登录')
    }
    
    try {
        const response = await axios.delete(
            `${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.DELETE_SESSION}`,
            {
                params: {
                    token: token,
                    sessionId: sessionId
                }
            }
        )
        return response.data
    } catch (error) {
        console.error('删除会话失败:', error)
        throw error
    }
}

/**
 * 检查后端服务是否可用
 * @returns {Promise<boolean>} 返回服务是否可用
 */
export async function checkServiceHealth() {
    try {
        const response = await axios.get(`${API_BASE_URL}${API_CONFIG.AI_ENDPOINTS.HEALTH}`, {
            timeout: 5000
        })
        return response.status === 200
    } catch (error) {
        console.error('服务健康检查失败:', error)
        return false
    }
}
